/*
 ### jQuery Multiple File Upload Plugin v1.47 - 2010-03-26 ###
 * Home: http://www.fyneworks.com/jquery/multiple-file-upload/
 * Code: http://code.google.com/p/jquery-multifile-plugin/
 *
 * Dual licensed under the MIT and GPL licenses:
 *   http://www.opensource.org/licenses/mit-license.php
 *   http://www.gnu.org/licenses/gpl.html
 ###
 */

/*# AVOID COLLISIONS #*/
;
if (window.jQuery)
    (function($) {
        /*# AVOID COLLISIONS #*/

        // plugin initialization
        $.fn.MultiFile = function(options) {
            if (this.length == 0)
                return this; // quick fail

            // Handle API methods
            if (typeof arguments[0] == 'string') {
                // Perform API methods on individual elements
                if (this.length > 1) {
                    var args = arguments;
                    return this.each(function() {
                        $.fn.MultiFile.apply($(this), args);
                    });
                }
                ;
                // Invoke API method handler
                $.fn.MultiFile[arguments[0]].apply(this, $.makeArray(arguments).slice(1) || []);
                // Quick exit...
                return this;
            }
            ;

            // Initialize options for this call
            var options = $.extend(
                    {}/* new object */,
                    $.fn.MultiFile.options/* default options */,
                    options || {} /* just-in-time options */
            );

            // Empty Element Fix!!!
            // this code will automatically intercept native form submissions
            // and disable empty file elements
            $('form')
                    .not('MultiFile-intercepted')
                    .addClass('MultiFile-intercepted')
                    .submit($.fn.MultiFile.disableEmpty);

            //### http://plugins.jquery.com/node/1363
            // utility method to integrate this plugin with others...
            if ($.fn.MultiFile.options.autoIntercept) {
                $.fn.MultiFile.intercept($.fn.MultiFile.options.autoIntercept /* array of methods to intercept */);
                $.fn.MultiFile.options.autoIntercept = null; /* only run this once */
            }
            ;

            // loop through each matched element
            this
                    .not('.MultiFile-applied')
                    .addClass('MultiFile-applied')
                    .each(function() {
                        //#####################################################################
                        // MAIN PLUGIN FUNCTIONALITY - START
                        //#####################################################################

                        // BUG 1251 FIX: http://plugins.jquery.com/project/comments/add/1251
                        // variable group_count would repeat itself on multiple calls to the plugin.
                        // this would cause a conflict with multiple elements
                        // changes scope of variable to global so id will be unique over n calls
                        window.MultiFile = (window.MultiFile || 0) + 1;
                        var group_count = window.MultiFile;

                        // Copy parent attributes - Thanks to Jonas Wagner
                        // we will use this one to create new input elements
                        var MultiFile = {e: this, E: $(this), clone: $(this).clone()};

                        //===

                        //# USE CONFIGURATION
                        if (typeof options == 'number')
                            options = {max: options};
                        var o = $.extend({},
                                $.fn.MultiFile.options,
                                options || {},
                                ($.metadata ? MultiFile.E.metadata() : ($.meta ? MultiFile.E.data() : null)) || {}, /* metadata options */
                                {} /* internals */
                        );
                        // limit number of files that can be selected?
                        if (!(o.max > 0) /*IsNull(MultiFile.max)*/) {
                            o.max = MultiFile.E.attr('maxlength');
                            if (!(o.max > 0) /*IsNull(MultiFile.max)*/) {
                                o.max = (String(MultiFile.e.className.match(/\b(max|limit)\-([0-9]+)\b/gi) || ['']).match(/[0-9]+/gi) || [''])[0];
                                if (!(o.max > 0))
                                    o.max = -1;
                                else
                                    o.max = String(o.max).match(/[0-9]+/gi)[0];
                            }
                        }
                        ;
                        o.max = new Number(o.max);
                        // limit extensions?
                        o.accept = o.accept || MultiFile.E.attr('accept') || '';
                        if (!o.accept) {
                            o.accept = (MultiFile.e.className.match(/\b(accept\-[\w\|]+)\b/gi)) || '';
                            o.accept = new String(o.accept).replace(/^(accept|ext)\-/i, '');
                        }
                        ;

                        //===

                        // APPLY CONFIGURATION
                        $.extend(MultiFile, o || {});
                        MultiFile.STRING = $.extend({}, $.fn.MultiFile.options.STRING, MultiFile.STRING);

                        //===

                        //#########################################
                        // PRIVATE PROPERTIES/METHODS
                        $.extend(MultiFile, {
                            n: 0, // How many elements are currently selected?
                            slaves: [], files: [],
                            instanceKey: MultiFile.e.id || 'MultiFile' + String(group_count), // Instance Key?
                            generateID: function(z) {
                                return MultiFile.instanceKey + (z > 0 ? '_F' + String(z) : '');
                            },
                            trigger: function(event, element) {
                                var handler = MultiFile[event], value = $(element).attr('value');
                                if (handler) {
                                    var returnValue = handler(element, value, MultiFile);
                                    if (returnValue != null)
                                        return returnValue;
                                }
                                return true;
                            }
                        });

                        //===

                        // Setup dynamic regular expression for extension validation
                        // - thanks to John-Paul Bader: http://smyck.de/2006/08/11/javascript-dynamic-regular-expresions/
                        if (String(MultiFile.accept).length > 1) {
                            MultiFile.accept = MultiFile.accept.replace(/\W+/g, '|').replace(/^\W|\W$/g, '');
                            MultiFile.rxAccept = new RegExp('\\.(' + (MultiFile.accept ? MultiFile.accept : '') + ')$', 'gi');
                        }
                        ;

                        //===

                        // Create wrapper to hold our file list
                        MultiFile.wrapID = MultiFile.instanceKey + '_wrap'; // Wrapper ID?
                        MultiFile.E.wrap('<div class="MultiFile-wrap" id="' + MultiFile.wrapID + '"></div>');
                        MultiFile.wrapper = $('#' + MultiFile.wrapID + '');

                        //===

                        // MultiFile MUST have a name - default: file1[], file2[], file3[]
                        MultiFile.e.name = MultiFile.e.name || 'file' + group_count + '[]';

                        //===

                        if (!MultiFile.list) {
                            // Create a wrapper for the list
                            // * OPERA BUG: NO_MODIFICATION_ALLOWED_ERR ('list' is a read-only property)
                            // this change allows us to keep the files in the order they were selected
                            MultiFile.wrapper.append('<div class="MultiFile-list" id="' + MultiFile.wrapID + '_list"></div>');
                            MultiFile.list = $('#' + MultiFile.wrapID + '_list');
                        }
                        ;
                        MultiFile.list = $(MultiFile.list);

                        //===

                        // Bind a new element
                        MultiFile.addSlave = function(slave, slave_count) {
                            //if(window.console) console.log('MultiFile.addSlave',slave_count);

                            // Keep track of how many elements have been displayed
                            MultiFile.n++;
                            // Add reference to master element
                            slave.MultiFile = MultiFile;

                            // BUG FIX: http://plugins.jquery.com/node/1495
                            // Clear identifying properties from clones
                            if (slave_count > 0)
                                slave.id = slave.name = '';

                            // Define element's ID and name (upload components need this!)
                            //slave.id = slave.id || MultiFile.generateID(slave_count);
                            if (slave_count > 0)
                                slave.id = MultiFile.generateID(slave_count);
                            //FIX for: http://code.google.com/p/jquery-multifile-plugin/issues/detail?id=23

                            // 2008-Apr-29: New customizable naming convention (see url below)
                            // http://groups.google.com/group/jquery-dev/browse_frm/thread/765c73e41b34f924#
                            slave.name = String(MultiFile.namePattern
                                    /*master name*/.replace(/\$name/gi, $(MultiFile.clone).attr('name'))
                                    /*master id  */.replace(/\$id/gi, $(MultiFile.clone).attr('id'))
                                    /*group count*/.replace(/\$g/gi, group_count)//(group_count>0?group_count:''))
                                    /*slave count*/.replace(/\$i/gi, slave_count)//(slave_count>0?slave_count:''))
                                    );

                            // If we've reached maximum number, disable input slave
                            if ((MultiFile.max > 0) && ((MultiFile.n - 1) > (MultiFile.max)))//{ // MultiFile.n Starts at 1, so subtract 1 to find true count
                                slave.disabled = true;
                            //};

                            // Remember most recent slave
                            MultiFile.current = MultiFile.slaves[slave_count] = slave;

                            // We'll use jQuery from now on
                            slave = $(slave);

                            // Clear value
                            slave.val('').attr('value', '')[0].value = '';

                            // Stop plugin initializing on slaves
                            slave.addClass('MultiFile-applied');

                            // Triggered when a file is selected
                            slave.change(function() {
                                //if(window.console) console.log('MultiFile.slave.change',slave_count);

                                // Lose focus to stop IE7 firing onchange again
                                $(this).blur();

                                //# Trigger Event! onFileSelect
                                if (!MultiFile.trigger('onFileSelect', this, MultiFile))
                                    return false;
                                //# End Event!

                                //# Retrive value of selected file from element
                                var ERROR = '', v = String(this.value || ''/*.attr('value)*/);

                                // check extension
                                if (MultiFile.accept && v && !v.match(MultiFile.rxAccept))//{
                                    ERROR = MultiFile.STRING.denied.replace('$ext', String(v.match(/\.\w{1,4}$/gi)));
                                //}
                                //};

                                // Disallow duplicates
                                for (var f in MultiFile.slaves)//{
                                    if (MultiFile.slaves[f] && MultiFile.slaves[f] != this)//{
                                        //console.log(MultiFile.slaves[f],MultiFile.slaves[f].value);
                                        if (MultiFile.slaves[f].value == v)//{
                                            ERROR = MultiFile.STRING.duplicate.replace('$file', v.match(/[^\/\\]+$/gi));
                                //};
                                //};
                                //};

                                // Create a new file input element
                                var newEle = $(MultiFile.clone).clone();// Copy parent attributes - Thanks to Jonas Wagner
                                //# Let's remember which input we've generated so
                                // we can disable the empty ones before submission
                                // See: http://plugins.jquery.com/node/1495
                                newEle.addClass('MultiFile');

                                // Handle error
                                if (ERROR != '') {
                                    // Handle error
                                    MultiFile.error(ERROR);

                                    // 2007-06-24: BUG FIX - Thanks to Adrian Wr�bel <adrian [dot] wrobel [at] gmail.com>
                                    // Ditch the trouble maker and add a fresh new element
                                    MultiFile.n--;
                                    MultiFile.addSlave(newEle[0], slave_count);
                                    slave.parent().prepend(newEle);
                                    slave.remove();
                                    return false;
                                }
                                ;

                                // Hide this element (NB: display:none is evil!)
                                $(this).css({position: 'absolute', top: '-3000px'});

                                // Add new element to the form
                                slave.after(newEle);

                                // Update list
                                MultiFile.addToList(this, slave_count);

                                // Bind functionality
                                MultiFile.addSlave(newEle[0], slave_count + 1);

                                //# Trigger Event! afterFileSelect
                                if (!MultiFile.trigger('afterFileSelect', this, MultiFile))
                                    return false;
                                //# End Event!

                            }); // slave.change()

                            // Save control to element
                            $(slave).data('MultiFile', MultiFile);

                        };// MultiFile.addSlave
                        // Bind a new element



                        // Add a new file to the list
                        MultiFile.addToList = function(slave, slave_count) {
                            //if(window.console) console.log('MultiFile.addToList',slave_count);

                            //# Trigger Event! onFileAppend
                            if (!MultiFile.trigger('onFileAppend', slave, MultiFile))
                                return false;
                            //# End Event!

                            // Create label elements
                            var
                                    r = $('<div class="MultiFile-label"></div>'),
                                    v = String(slave.value || ''/*.attr('value)*/),
                                    a = $('<span class="MultiFile-title" title="' + MultiFile.STRING.selected.replace('$file', v) + '">' + MultiFile.STRING.file.replace('$file', v.match(/[^\/\\]+$/gi)[0]) + '</span>'),
                                    b = $('<a class="MultiFile-remove" href="#' + MultiFile.wrapID + '">' + MultiFile.STRING.remove + '</a>');

                            // Insert label
                            MultiFile.list.append(
                                    r.append(b, ' ', a)
                                    );

                            b
                                    .click(function() {

                                        //# Trigger Event! onFileRemove
                                        if (!MultiFile.trigger('onFileRemove', slave, MultiFile))
                                            return false;
                                        //# End Event!

                                        MultiFile.n--;
                                        MultiFile.current.disabled = false;

                                        // Remove element, remove label, point to current
                                        MultiFile.slaves[slave_count] = null;
                                        $(slave).remove();
                                        $(this).parent().remove();

                                        // Show most current element again (move into view) and clear selection
                                        $(MultiFile.current).css({position: '', top: ''});
                                        $(MultiFile.current).reset().val('').attr('value', '')[0].value = '';

                                        //# Trigger Event! afterFileRemove
                                        if (!MultiFile.trigger('afterFileRemove', slave, MultiFile))
                                            return false;
                                        //# End Event!

                                        return false;
                                    });

                            //# Trigger Event! afterFileAppend
                            if (!MultiFile.trigger('afterFileAppend', slave, MultiFile))
                                return false;
                            //# End Event!

                        }; // MultiFile.addToList
                        // Add element to selected files list



                        // Bind functionality to the first element
                        if (!MultiFile.MultiFile)
                            MultiFile.addSlave(MultiFile.e, 0);

                        // Increment control count
                        //MultiFile.I++; // using window.MultiFile
                        MultiFile.n++;

                        // Save control to element
                        MultiFile.E.data('MultiFile', MultiFile);


                        //#####################################################################
                        // MAIN PLUGIN FUNCTIONALITY - END
                        //#####################################################################
                    }); // each element
        };

        /*--------------------------------------------------------*/

        /*
         ### Core functionality and API ###
         */
        $.extend($.fn.MultiFile, {
            /**
             * This method removes all selected files
             *
             * Returns a jQuery collection of all affected elements.
             *
             * @name reset
             * @type jQuery
             * @cat Plugins/MultiFile
             * @author Diego A. (http://www.fyneworks.com/)
             *
             * @example $.fn.MultiFile.reset();
             */
            reset: function() {
                var settings = $(this).data('MultiFile');
                //if(settings) settings.wrapper.find('a.MultiFile-remove').click();
                if (settings)
                    settings.list.find('a.MultiFile-remove').click();
                return $(this);
            },
            /**
             * This utility makes it easy to disable all 'empty' file elements in the document before submitting a form.
             * It marks the affected elements so they can be easily re-enabled after the form submission or validation.
             *
             * Returns a jQuery collection of all affected elements.
             *
             * @name disableEmpty
             * @type jQuery
             * @cat Plugins/MultiFile
             * @author Diego A. (http://www.fyneworks.com/)
             *
             * @example $.fn.MultiFile.disableEmpty();
             * @param String class (optional) A string specifying a class to be applied to all affected elements - Default: 'mfD'.
             */
            disableEmpty: function(klass) {
                klass = (typeof (klass) == 'string' ? klass : '') || 'mfD';
                var o = [];
                $('input:file.MultiFile').each(function() {
                    if ($(this).val() == '')
                        o[o.length] = this;
                });
                return $(o).each(function() {
                    this.disabled = true
                }).addClass(klass);
            },
            /**
             * This method re-enables 'empty' file elements that were disabled (and marked) with the $.fn.MultiFile.disableEmpty method.
             *
             * Returns a jQuery collection of all affected elements.
             *
             * @name reEnableEmpty
             * @type jQuery
             * @cat Plugins/MultiFile
             * @author Diego A. (http://www.fyneworks.com/)
             *
             * @example $.fn.MultiFile.reEnableEmpty();
             * @param String klass (optional) A string specifying the class that was used to mark affected elements - Default: 'mfD'.
             */
            reEnableEmpty: function(klass) {
                klass = (typeof (klass) == 'string' ? klass : '') || 'mfD';
                return $('input:file.' + klass).removeClass(klass).each(function() {
                    this.disabled = false
                });
            },
            /**
             * This method will intercept other jQuery plugins and disable empty file input elements prior to form submission
             *
             
             * @name intercept
             * @cat Plugins/MultiFile
             * @author Diego A. (http://www.fyneworks.com/)
             *
             * @example $.fn.MultiFile.intercept();
             * @param Array methods (optional) Array of method names to be intercepted
             */
            intercepted: {},
            intercept: function(methods, context, args) {
                var method, value;
                args = args || [];
                if (args.constructor.toString().indexOf("Array") < 0)
                    args = [args];
                if (typeof (methods) == 'function') {
                    $.fn.MultiFile.disableEmpty();
                    value = methods.apply(context || window, args);
                    //SEE-http://code.google.com/p/jquery-multifile-plugin/issues/detail?id=27
                    setTimeout(function() {
                        $.fn.MultiFile.reEnableEmpty()
                    }, 1000);
                    return value;
                }
                ;
                if (methods.constructor.toString().indexOf("Array") < 0)
                    methods = [methods];
                for (var i = 0; i < methods.length; i++) {
                    method = methods[i] + ''; // make sure that we have a STRING
                    if (method)
                        (function(method) { // make sure that method is ISOLATED for the interception
                            $.fn.MultiFile.intercepted[method] = $.fn[method] || function() {
                            };
                            $.fn[method] = function() {
                                $.fn.MultiFile.disableEmpty();
                                value = $.fn.MultiFile.intercepted[method].apply(this, arguments);
                                //SEE-http://code.google.com/p/jquery-multifile-plugin/issues/detail?id=27
                                setTimeout(function() {
                                    $.fn.MultiFile.reEnableEmpty()
                                }, 1000);
                                return value;
                            }; // interception
                        })(method); // MAKE SURE THAT method IS ISOLATED for the interception
                }
                ;// for each method
            } // $.fn.MultiFile.intercept

        });

        /*--------------------------------------------------------*/

        /*
         ### Default Settings ###
         eg.: You can override default control like this:
         $.fn.MultiFile.options.accept = 'gif|jpg';
         */
        $.fn.MultiFile.options = {//$.extend($.fn.MultiFile, { options: {
            accept: '', // accepted file extensions
            max: -1, // maximum number of selectable files

            // name to use for newly created elements
            namePattern: '$name', // same name by default (which creates an array)

            // STRING: collection lets you show messages in different languages
            STRING: {
                remove: 'x',
                denied: 'You cannot select a $ext file.\nTry again...',
                file: '$file',
                selected: 'File selected: $file',
                duplicate: 'This file has already been selected:\n$file'
            },
            // name of methods that should be automcatically intercepted so the plugin can disable
            // extra file elements that are empty before execution and automatically re-enable them afterwards
            autoIntercept: ['submit', 'ajaxSubmit', 'ajaxForm', 'validate', 'valid' /* array of methods to intercept */],
            // error handling function
            error: function(s) {
                /*
                 ERROR! blockUI is not currently working in IE
                 if($.blockUI){
                 $.blockUI({
                 message: s.replace(/\n/gi,'<br/>'),
                 css: { 
                 border:'none', padding:'15px', size:'12.0pt',
                 backgroundColor:'#900', color:'#fff',
                 opacity:'.8','-webkit-border-radius': '10px','-moz-border-radius': '10px'
                 }
                 });
                 window.setTimeout($.unblockUI, 2000);
                 }
                 else//{// save a byte!
                 */
                alert(s);
                //}// save a byte!
            }
        }; //} });

        /*--------------------------------------------------------*/

        /*
         ### Additional Methods ###
         Required functionality outside the plugin's scope
         */

        // Native input reset method - because this alone doesn't always work: $(element).val('').attr('value', '')[0].value = '';
        $.fn.reset = function() {
            return this.each(function() {
                try {
                    this.reset();
                } catch (e) {
                }
            });
        };

        /*--------------------------------------------------------*/

        /*
         ### Default implementation ###
         The plugin will attach itself to file inputs
         with the class 'multi' when the page loads
         */
        $(function() {
            //$("input:file.multi").MultiFile();
            $("input[type=file].multi").MultiFile();
        });



        /*# AVOID COLLISIONS #*/
    })(jQuery);
/*# AVOID COLLISIONS #*/
